package com.joeyzh.net;

import android.text.TextUtils;

import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonSyntaxException;
import com.joey.base.OnLoadingListener;
import com.joey.base.util.LogUtils;
import com.joey.protocol.JSONResponseListener;
import com.joey.protocol.ResponseError;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by Joey on 2018/12/7.
 *
 * @author by Joey
 *         UA公共解析类
 */

public abstract class UAResponseListener<T extends JsonElement> extends JSONResponseListener<T> {
    /**
     * 固定格式的提示信息内容
     */
    private final String MSG_KEYS[] = {"message", "error_description"};
    /**
     * 固定格式的错误码内容
     */
    private final String CODE_KEYS[] = {"code", "error"};

    private final String CONST_ERROR = "error";

    /**
     * 使用odata查询时，解析的返回结果
     */
    private final String VALUE_KEY = "value";
    /**
     * 表示提交表单等非odata方式访问接口时，返回解析错误码的部分
     */
    private final String ERROR_KEY_SUCCESS = "Error";

    public UAResponseListener(OnLoadingListener onLoadingListener) {
        super(onLoadingListener);
    }


    public UAResponseListener() {

    }

    @Override
    public void convert(String s) {
        Gson gson = new Gson();
        try {
            JsonObject root = gson.fromJson(s, JsonObject.class);
            /**
             * odata查询时，取出value的值，作为查询结果
             */
            if (root.has(VALUE_KEY)) {
                onResponse((T) root.get(VALUE_KEY), error);
                return;
            }
            UAError error = new UAError();
            /**
             * 接口请求成功，解析错误码
             */
            if (root.has(ERROR_KEY_SUCCESS)) {
                error = gson.fromJson(root.get("Error"), UAError.class);
                /**
                 * 其他情况格式不正确时，遍历结果，直接取出value,如果遍历结束后找不到value，就返回根节点
                 */
                onResponse((T) parseValue(root), error);
                return;
            }
            /**
             * 其他不规则接口
             */
            onResponse((T) root, error);

        } catch (JsonSyntaxException e) {
            e.printStackTrace();
            handleError(new ResponseError(ResponseError.ERROR_BY_PARSE, s));

        } catch (Exception e) {
            e.printStackTrace();
            handleError(new ResponseError(ResponseError.ERROR_BY_PARSE, s));
        }

    }

    private JsonElement parseValue(JsonObject root) {
        for (Map.Entry<String, JsonElement> item : root.entrySet()) {
            if (item.getKey().startsWith("@odata")) {
                continue;
            }
            if (item.getKey().equals("Succeeded")) {
                continue;
            }
            if (item.getKey().equals("Error")) {
                continue;
            }
            return item.getValue();
        }
        return root;
    }

    @Override
    protected void handleError(ResponseError error) {
        if (!TextUtils.isEmpty(error.getMessage())) {
            super.handleError(error);
            return;
        }
        JsonObject object = (JsonObject) error.getResult();
        /**
         *这种错格式
         {"error":{"code":"6401","message":"Authorization has been denied for this request. Accept only requests with a token","innererror":{}}}","Success":"401","ReturnMsg":""}
         */
        if (object.has(CONST_ERROR)) {
            if (object.get(CONST_ERROR).isJsonObject()) {
                error.setResult(object.get(CONST_ERROR).getAsJsonObject());
                handleError(error);
                return;
            }
        }
        /**
         * 循环遍历取出错误提示内容
         */
        int i = 0;
        for (String msgKey : MSG_KEYS) {
            if (object.has(msgKey)) {
                error.setMessage(object.get(msgKey).getAsString());
                error.setStatus(object.get(CODE_KEYS[i]).getAsString());
                super.handleError(error);
                return;
            }
            i++;
        }
        error.setMessage(object.toString());
        super.handleError(error);
    }
}
